home *** CD-ROM | disk | FTP | other *** search
/ CD Actual 9 / CDACTUAL9.iso / share / Dos / VARIOS / pascal / SWAG9605.DDD / 0123_Re: Hardware delays on all Platforms.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  1996-05-31  |  8.6 KB  |  188 lines
  1. {
  2. >The hardware requires several types of simple 'wait' delay from about
  3. >100us through to 100's of ms. Currently this is done using a
  4. >software-calibrated technique and count loops, but a (say) 10ms delay is
  5. >only about 5% accurate. To improve this operation, I propose to change to
  6. >the following:
  7. >
  8. >If my app is running in DOS only (real or DPMI).
  9. >------------------------------------------------
  10. >To use a standard 'timer'-based unit which is known to be solid with the
  11. >PC timer to generate delays. (Eg Turbopowers sample file).
  12. >
  13. >If my app is running as a DOS app under Windows.
  14. >------------------------------------------------
  15. >The standard 'timer'-based unit above does NOT work now - presumably
  16. >because Windows virtualises the timer. In this mode I would like my
  17. >(DOS!) app to be able to access MMSYSTEM to get at its timer services.
  18. >
  19. >
  20. >So to the questions.
  21. >1. How can a DPMI program running under windows get at (say) MMSYSTEM?
  22. >2. Is it possible for a real-mode DOS program running under windows to
  23. >get at any of these services?
  24. >
  25.  
  26. Don't know about any of that but there is a way to get at the microtimer
  27. port on any computer above an "AT" here is the code }
  28.  
  29. {
  30. In <Ds2woK.CCA@cix.compulink.co.uk>, bfrost@cix.compulink.co.uk ("Brian Frost") writes:
  31. >Well, I've tried ReadMicroTimer and it looked promising at first. If you 
  32. >call it (in BP7 but under W95) in a simple routine to loop reading it 
  33. >until an elapsed duration is complete, it works for durations > 100,000 
  34. >counts (each count is actually 0.8us I think) but if you then try 10,000 
  35. >counts it appears that the routine actually hangs around looping on 
  36. >something and times go out by a factor of 5 or so.
  37.  
  38. The code was for micro timing not for long delays you've got the interrupts
  39. held up while it does the reads thus when the interrupt routines come 
  40. through between calls they upset the timing! For OS2 native mode you can use the following code on a compiler such as speed or Virtual Pascal
  41.  
  42. {$IFNDEF OS2}                                         { Non OS2 version }
  43. FUNCTION ReadMicroTimer: LongInt; ASSEMBLER;
  44. ASM  { Read the system timer With 1 microsecond resolution }
  45.    CLI;                                               { Disable interrupts }
  46.    MOV AL, 0AH;                                       { Set irr address }
  47.    OUT 20H, AL;                                       { Ask to read irr }
  48.    MOV AL, 00H;                                       { Value to set timer }
  49.    OUT 43H, AL;                                       { Set timer 0 latch }
  50.    IN AL, DX;                                         { Read irr value }
  51.    MOV DI, AX;                                        { Save value in DI }
  52.    IN AL, 40H;                                        { Read counter value }
  53.    MOV BL, AL;                                        { LSB in BL }
  54.    IN AL, 40H;                                        { Read counter value }
  55.    MOV BH, AL;                                        { MSB in BH }
  56.    NOT BX;                                            { Asscending count }
  57.    IN AL, 21H;                                        { Read PIC imr }
  58.    MOV SI, AX;                                        { Save value in SI }
  59.    MOV AL, 0FFH;                                      { Mask all interrupts }
  60.    OUT 21H, AL;                                       { Stop all interrupts }
  61.    MOV AX, [Seg0040];                                 { Dos data segment }
  62.    MOV ES, AX;                                        { Set register }
  63.    MOV DX, ES:[006CH];                                { Read time clock }
  64.    MOV AX, SI;                                        { Reload PIC imr }
  65.    OUT 21H, AL;                                       { Restore interrupts }
  66.    STI;                                               { Enable interrupts }
  67.    MOV AX, DI;                                        { Retreive old irr }
  68.    TEST AL, 01H;                                      { Counter hit 0 }
  69.    JZ @@Done;                                         { Count complete }
  70.    CMP BX, 0FF00H;                                    { Counter > $FFxx }
  71.    JA @@Done;                                         { Counter complete }
  72.    INC DX;                                            { Count irq request }
  73. @@Done:
  74.    MOV AX, BX;                                        { Return time pulses }
  75. END;
  76. {$ELSE}                                               { OS2 version }
  77. FUNCTION ReadMicroTimer: LongInt;
  78. VAR Value: LongInt;
  79. BEGIN
  80.    DosQuerySysInfo(qsv_Ms_Count, qsv_Ms_Count,
  81.        Value, SizeOf(Value));                         { Issue query }
  82.    ReadMicroTimer := Value;                           { Return timer }
  83. END;
  84. {$ENDIF}
  85.  
  86. Longer delays can be done with code like
  87.  
  88. CONST
  89.    DelayCount : LongInt = 0;                          { Delay cycle counts }
  90.    HrtimerRate: Longint = 1193182;                    { RTC Timer rate }
  91.  
  92. {$IFNDEF OS2}                                         { Non OS2 version }
  93. PROCEDURE Delay (MilliSecs: Word); ASSEMBLER;
  94. ASM
  95.    CMP WORD PTR [DelayCount], 0;
  96.    JNZ @@AlreadyInstalled;                            { Delay installed }
  97.    MOV AX, [Seg0040];
  98.    MOV ES, AX;                                        { DOS Data segment }
  99.    MOV SI, 006CH;
  100.    MOV AX, ES:[SI];                                   { Read DOS clock }
  101. @@DifferWait:
  102.    CMP AX, ES:[SI];
  103.    JZ @@DifferWait;                                   { Wait for change }
  104.    MOV AX, ES:[SI];
  105.    MOV CX, 0FFFFH;                                    { Preset count }
  106. @@DifferWait1:
  107.    CMP AX, ES:[SI];
  108.    JNZ @@Differs;                                     { Wait for tick }
  109.    LOOP @@DifferWait1;
  110. @@Differs:
  111.    MOV AX, 0037H;
  112.    XCHG CX, AX;                                       { Calculate delay }
  113.    NOT AX;
  114.    XOR DX, DX;
  115.    DIV CX;
  116.    MOV WORD PTR [DelayCount], AX;                     { Hold delay count }
  117. @@AlreadyInstalled:
  118.    MOV DX, [MilliSecs];                               { Retreive delay }
  119. @@CountLoop:
  120.    OR DX, DX;
  121.    JZ @@Exit;                                         { Zero delay exit }
  122.    XOR SI, SI;
  123.    MOV AX, [Seg0040];                                 { Load address }
  124.    MOV ES, AX;
  125.    MOV AX, ES:[SI];
  126.    MOV CX, WORD PTR [DelayCount];                     { Load delay count }
  127. @@Wait2:
  128.    CMP AX, ES:[SI];
  129.    JNZ @@Over;
  130.    LOOP @@Wait2;                                      { Wait 1ms }
  131. @@Over:
  132.    DEC DX;
  133.    JNZ @@CountLoop;                                   { Repeat 1ms delay }
  134. @@Exit:
  135. END;
  136. {$ELSE}                                               { OS2 version }
  137.  
  138. { Waits for next timer tick or delays 1ms }
  139.  
  140. FUNCTION DelayLoop (Count: Longint; Var StartValue: LongInt): Longint;
  141. VAR Value: LongInt;
  142. BEGIN
  143.    Repeat
  144.      DosQuerySysInfo(qsv_Ms_Count, qsv_Ms_Count,
  145.        Value, SizeOf(Value));                         { Get timer count }
  146.      Dec(Count);                                      { Count down }
  147.    Until (Value <> StartValue) OR (Count = -1);
  148.    StartValue := Value;                               { Update start }
  149.    DelayLoop := Count;                                { Return result }
  150. END;
  151.  
  152. { Calculates 1ms delay count for DelayLoop routine. }
  153. { CalcDelayCount is called once at startup.         }
  154.  
  155. PROCEDURE CalcDelayCount;
  156. VAR Interval, StartValue, Value: LongInt;
  157. BEGIN
  158.    DosQuerySysInfo(qsv_Timer_Interval, qsv_Timer_Interval,
  159.     Interval, SizeOf(Interval));                      {  Get timer interval }
  160.    DosQuerySysInfo(qsv_Ms_Count, qsv_Ms_Count,
  161.     StartValue, SizeOf(StartValue));                  { Get timer count }
  162.    Repeat
  163.      DosQuerySysInfo(qsv_Ms_Count, qsv_Ms_Count,
  164.        Value, SizeOf(Value));                         { Get timer timer }
  165.    Until (Value <> StartValue);
  166.    TenthsCount := -DelayLoop(-1, Value) DIV Interval; { Tenths count}
  167.    DelayCount := TenthsCount * 10;                    { Delay count }
  168. END;
  169.  
  170. PROCEDURE Delay (MilliSecs: Word);
  171. VAR StartValue, Value: LongInt; Count: Longint;
  172. BEGIN
  173.    If (DelayCount=0) Then CalcDelayCount;             { Calc delay count }
  174.    If (MilliSecs >= (5*31)) Then DosSleep(MilliSecs)  { Long delay sleep }
  175.    Else Begin
  176.      DosQuerySysInfo(qsv_Ms_Count, qsv_Ms_Count,
  177.      StartValue, SizeOf(StartValue));                 { Issue query }
  178.      Value := StartValue;                             { Hold start value }
  179.      Count := MilliSecs;                              { Load count }
  180.      Repeat
  181.        DelayLoop(DelayCount, Value);                  { Call delay loop }
  182.        Dec(Count);                                    { 1 millisec down }
  183.      Until (Value-StartValue >= MilliSecs) OR
  184.      (Count <= 0);                                    { Delay complete }
  185.    End;
  186. END;
  187. {$ENDIF}
  188.